home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / gfx / conv / jpegV5Asrc.lha / jpeg-5a / jmemnobs.c < prev    next >
C/C++ Source or Header  |  1994-07-27  |  3KB  |  110 lines
  1. /*
  2.  * jmemnobs.c
  3.  *
  4.  * Copyright (C) 1992-1994, Thomas G. Lane.
  5.  * This file is part of the Independent JPEG Group's software.
  6.  * For conditions of distribution and use, see the accompanying README file.
  7.  *
  8.  * This file provides a really simple implementation of the system-
  9.  * dependent portion of the JPEG memory manager.  This implementation
  10.  * assumes that no backing-store files are needed: all required space
  11.  * can be obtained from malloc().
  12.  * This is very portable in the sense that it'll compile on almost anything,
  13.  * but you'd better have lots of main memory (or virtual memory) if you want
  14.  * to process big images.
  15.  * Note that the max_memory_to_use option is ignored by this implementation.
  16.  */
  17.  
  18. #define JPEG_INTERNALS
  19. #include "jinclude.h"
  20. #include "jpeglib.h"
  21. #include "jmemsys.h"        /* import the system-dependent declarations */
  22.  
  23. #ifndef HAVE_STDLIB_H        /* <stdlib.h> should declare malloc(),free() */
  24. extern void * malloc JPP((size_t size));
  25. extern void free JPP((void *ptr));
  26. #endif
  27.  
  28.  
  29. /*
  30.  * Memory allocation and freeing are controlled by the regular library
  31.  * routines malloc() and free().
  32.  */
  33.  
  34. GLOBAL void *
  35. jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
  36. {
  37.   return (void *) malloc(sizeofobject);
  38. }
  39.  
  40. GLOBAL void
  41. jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
  42. {
  43.   free(object);
  44. }
  45.  
  46.  
  47. /*
  48.  * "Large" objects are treated the same as "small" ones.
  49.  * NB: although we include FAR keywords in the routine declarations,
  50.  * this file won't actually work in 80x86 small/medium model; at least,
  51.  * you probably won't be able to process useful-size images in only 64KB.
  52.  */
  53.  
  54. GLOBAL void FAR *
  55. jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
  56. {
  57.   return (void FAR *) malloc(sizeofobject);
  58. }
  59.  
  60. GLOBAL void
  61. jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
  62. {
  63.   free(object);
  64. }
  65.  
  66.  
  67. /*
  68.  * This routine computes the total memory space available for allocation.
  69.  * Here we always say, "we got all you want bud!"
  70.  */
  71.  
  72. GLOBAL long
  73. jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
  74.             long max_bytes_needed, long already_allocated)
  75. {
  76.   return max_bytes_needed;
  77. }
  78.  
  79.  
  80. /*
  81.  * Backing store (temporary file) management.
  82.  * Since jpeg_mem_available always promised the moon,
  83.  * this should never be called and we can just error out.
  84.  */
  85.  
  86. GLOBAL void
  87. jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
  88.              long total_bytes_needed)
  89. {
  90.   ERREXIT(cinfo, JERR_NO_BACKING_STORE);
  91. }
  92.  
  93.  
  94. /*
  95.  * These routines take care of any system-dependent initialization and
  96.  * cleanup required.  Here, there isn't any.
  97.  */
  98.  
  99. GLOBAL long
  100. jpeg_mem_init (j_common_ptr cinfo)
  101. {
  102.   return 0;            /* just set max_memory_to_use to 0 */
  103. }
  104.  
  105. GLOBAL void
  106. jpeg_mem_term (j_common_ptr cinfo)
  107. {
  108.   /* no work */
  109. }
  110.